package com.googlecode.kipler.satisfiability.completion.rule.individual;

import com.googlecode.kipler.container.dl.ConceptCategory;
import com.googlecode.kipler.container.dl.Individual;
import com.googlecode.kipler.container.dl.World;
import com.googlecode.kipler.container.dl.WorldConstraintSystem;
import com.googlecode.kipler.satisfiability.blocking.abox.ABoxBlockingStrategy;
import com.googlecode.kipler.satisfiability.completion.rule.individual.uniformnotation.UntilBetaConcept;
import com.googlecode.kipler.satisfiability.reasoner.Reasoner;
import com.googlecode.kipler.satisfiability.reasoner.ReasonerException;


public class UntilConceptRule extends ABoxRule {

	private BetaConceptRule betaRule;

	public UntilConceptRule(Reasoner prover, ABoxBlockingStrategy blocking) {
		betaRule = new BetaConceptRule(prover, blocking, ConceptCategory.UNTIL,
				new UntilBetaConcept(), true, "Until concept rule");
	}

	public void apply() throws ReasonerException {
		betaRule.apply();
	}

	public ABoxBlockingStrategy getBlocking() {
		return betaRule.getBlocking();
	}

	public Individual getIndividual() {
		return betaRule.getIndividual();
	}

	public WorldConstraintSystem getWcs() {
		return betaRule.getWcs();
	}

	public World getWorld() {
		return betaRule.getWorld();
	}

	public boolean isApplied() {
		return betaRule.isApplied();
	}

	public void setBlocking(ABoxBlockingStrategy blocking) {
		betaRule.setBlocking(blocking);
	}

	public void setIndividual(Individual individual) {
		betaRule.setIndividual(individual);
	}

	public void setWcs(WorldConstraintSystem wcs) {
		betaRule.setWcs(wcs);
	}

	public void setWorld(World world) {
		betaRule.setWorld(world);
	}

}
